/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package server.comunicacion;

import com.mysql.jdbc.exceptions.MySQLIntegrityConstraintViolationException;
import herramientas.Agente_Properties;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.sql.SQLException;
import java.util.Date;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import server.dominio.Beneficiario;
import server.dominio.Cita;
import server.dominio.Medico;
import server.dominio.Usuario;
import server.excepciones.BeneficiarioInexistenteException;
import server.excepciones.BeneficiarioNoExistenteException;
import server.excepciones.BeneficiarioYaExistenteException;
import server.excepciones.CitaNoValidaException;
import server.excepciones.FechaNoValidaException;
import server.excepciones.MedicoInexistenteException;
import server.excepciones.MedicoNoExistenteException;
import server.excepciones.MedicoYaExistenteException;
import server.excepciones.UsuarioNoExistenteException;
import server.excepciones.UsuarioYaExistenteException;
import serverb.comunicacion.IServidorB;

/**
 *
 * @author tpaxl
 */
public class proxyServA implements Serializable{
    private static proxyServA proxy=null;
    private final IServidorB servidorB;
    private String ip="localhost";
    private String puerto="3000";

    private proxyServA() throws MalformedURLException, RemoteException, NotBoundException {
        try {
            //Obtencion de datos
            Agente_Properties agentep = Agente_Properties.getAgenteProperties();
            ip= agentep.getProperty("servidorB.ip");
            puerto= agentep.getProperty("servidorB.puerto");
            agentep.cerrar();
        } catch (FileNotFoundException ex) {
            Logger.getLogger(proxyServA.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(proxyServA.class.getName()).log(Level.SEVERE, null, ex);
        }
            this.servidorB = (IServidorB) Naming.lookup("rmi://"+ip+":"+puerto+"/ServidorB");

	}
        public static proxyServA getProxy() throws MalformedURLException, RemoteException, NotBoundException{

            if(proxy== null){
                proxy= new proxyServA();
            }
            return proxy;
        }


      	public void crear(long idSesion, Beneficiario beneficiario) throws RemoteException, BeneficiarioYaExistenteException, SQLException, Exception {

        }

        public boolean insertarMedico(Medico med) throws RemoteException, MedicoYaExistenteException, Exception {
            boolean retorno = false;
            try {
                servidorB.crear(med);
                retorno= true;
            } catch (RemoteException ex) {
                System.out.println("Error de conexion: "+ ex);
            } catch (SQLException ex) {
                System.out.println("Error de conexion: "+ ex);
            }
            return retorno;
        }

        public boolean modificar(Beneficiario bene) throws BeneficiarioNoExistenteException, Exception{
            boolean retorno = false;
            try {
                servidorB.modificar(bene);
                retorno= true;
            } catch (RemoteException ex) {
                System.out.println("Error de conexion: "+ ex);
            } catch (MySQLIntegrityConstraintViolationException ex) {
                retorno=true;
            } catch (SQLException ex){}
            return retorno;
        }


        public boolean modificar(Medico medico) throws MedicoYaExistenteException, Exception {
            boolean retorno = false;
            try {
                servidorB.modificar(medico);
                retorno= true;
            } catch (RemoteException ex) {
                System.out.println("Error de conexion: "+ ex);
            } catch (SQLException ex) {
                System.out.println("Error de conexion: "+ ex);
            } 
            return retorno;
        }

        public boolean modificarUsuario(Usuario usuario) throws Exception {
            boolean retorno = false;
            try {
                servidorB.modificar(usuario);
                retorno= true;
            } catch (RemoteException ex) {
                System.out.println("Error de conexion: "+ ex);
            } catch (SQLException ex) {
                System.out.println("Error de conexion: "+ ex);
            } 
            return retorno;
        }
        public boolean modificarUsuarioM(Usuario medico_aux) throws MedicoYaExistenteException, Exception{
            boolean retorno = false;
            try {
                servidorB.modificarM(medico_aux);
                retorno= true;
            } catch (RemoteException ex) {
                System.out.println("Error de conexion: "+ ex);
            } catch (SQLException ex) {
                System.out.println("Error de conexion: "+ ex);
                retorno= true;
            } 
            return retorno;
        }


    public boolean borrarUsuario(Usuario usuario) throws UsuarioNoExistenteException, Exception {
        boolean retorno = false;
        try {
            servidorB.borrarUsuario(usuario);
            retorno= true;
        } catch (RemoteException ex) {
            System.out.println("Error de conexion: "+ ex);
        } catch (SQLException ex) {
            System.out.println("Error de conexion: "+ ex);
        } 
        return retorno;
    }

    public boolean borrarMedico(Medico medico) throws MedicoNoExistenteException, Exception {
        boolean retorno = false;
        try {
            servidorB.eliminar(medico);
            retorno= true;
        } catch (RemoteException ex) {
            System.out.println("Error de conexion: "+ ex);
        }
        catch (com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException ex){
            retorno = true;
        }
        catch (SQLException ex) {
                       System.out.println("Error de conexion: "+ ex);
        } 
        return retorno;
    }


    public boolean insertarBeneficiario(Beneficiario beneficiario) throws BeneficiarioYaExistenteException, Exception {
        boolean retorno = false;
        try {
            servidorB.crear(beneficiario);
            retorno= true;
        } catch (RemoteException ex) {
            System.out.println("Error de conexion: "+ ex);
        } catch (SQLException ex) {
            System.out.println("Error de conexion: "+ ex);
        } 
        return retorno;
    }

    public boolean borrarBeneficiario(Beneficiario beneficiario) throws BeneficiarioNoExistenteException, Exception{
        boolean retorno = false;
        try {
            servidorB.eliminar(beneficiario);
            retorno= true;
        } catch (RemoteException ex) {
            System.out.println("Error de conexion: "+ ex);
        } catch (SQLException ex) {
            System.out.println("Error de conexion: "+ ex);
        }
        return retorno;
    }

    public void refrescarCalendario(Medico medicoseleccionado) throws RemoteException, Exception {
        servidorB.refrescar(medicoseleccionado);
    }

    public boolean insertarUsuario(Object usuario) throws UsuarioYaExistenteException, Exception {
        boolean retorno= false;
        Usuario usuario_aux= (Usuario)usuario;
        try {
            servidorB.crear(usuario_aux);
            retorno= true;
        } catch (RemoteException ex) {
            System.out.println("horror conexion "+ ex);
        } catch (SQLException ex) {
            System.out.println("horror SQL insertarUsuario "+ex);
        } 
        return retorno;
    }

    public void insertarDatos(Medico medico, Vector<Date> dias, Date horaDesde, Date horaHasta) throws RemoteException, MedicoInexistenteException, Exception {
        servidorB.modificarCalendario(medico, dias, horaDesde, horaHasta, null);
    }


    public boolean pedirCita(Beneficiario beneficiario, String idMedico_pk, Date fecha_trabajo) throws BeneficiarioInexistenteException, MedicoInexistenteException, FechaNoValidaException, Exception {
        boolean retorno = false;
        try {
            servidorB.pedirCita(beneficiario, idMedico_pk, fecha_trabajo);
            retorno= true;
        } catch (RemoteException ex) {
            Logger.getLogger(proxyServA.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(proxyServA.class.getName()).log(Level.SEVERE, null, ex);
        } 
        return retorno;
    }

    public boolean rechazarCita(Cita cita_aux) throws CitaNoValidaException, Exception {
        boolean retorno= false;
        try {
            servidorB.anularCita(cita_aux);
            retorno= true;
        } catch (RemoteException ex) {
            Logger.getLogger(proxyServA.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(proxyServA.class.getName()).log(Level.SEVERE, null, ex);
        }
        return retorno;
    }
}
